package zeno.project.springboot.util;

/**
 * 数据转换，如进制转换、时间转换等
 * @author zhiyong
 */
public class DataConversionUtil {
    private static final String str = "hello";
    private static final byte aByte = 1;
    private static final byte[] bytes = {1,2,3};
    private static final int anInt = 2;
    private static final char[] HEXES = {
            '0', '1', '2', '3',
            '4', '5', '6', '7',
            '8', '9', 'a', 'b',
            'c', 'd', 'e', 'f'
    };

    public static void main(String[] args) {
        statistics();
    }

    /**
     * 统计二进制数中1的个数
     */
    private static void statistics() {
        byte option = 0x71;
        byte x = (byte) (option & 0xff);
        // 每两个二进制位各有多少个1
        x = (byte) ((x & 0x55) + ((x >> 1) & 0x55));
        // 每四个二进制位各有多少个1
        x = (byte) ((x & 0x33) + ((x >> 2) & 0x33));
        // 每八个（正好只有八个）二进制位各有多少各1
        x = (byte) ((x & 0x0f) + ((x >> 4) & 0x0f));
        System.out.println(x);
    }

    /**
     * byte转为 无符号整数的int，正数以上的byte的int即它本身，在 0 ~ 255间循环，即 255 => 255, -256|256 => 0。负数反之。为-255 ~ 0，-255 =》 1，-254 =》 2
     * @param b 字节，数据范围为-128 ~ 127，对应无符号int的值为 0 ~ 256，-128|128 => 128，-127 => 129，127 => 127
     * @return 无符号整数的int
     */
    public static int byte2UnsignedInt(byte b) {
        return b & 0xFF;
    }

    /**
     * 将一个字节与字节数组合并
     * @param bs bs
     * @param b b
     * @param isTail 是否添加到尾部
     * @return 合并结果
     */
    public static byte[] mergeBytes(byte[] bs,byte b, boolean isTail) {
        byte[] temp = new byte[bs.length + 1];
        for (int i = 0; i < bs.length; i++) {
            // 判断是否插入尾部，是则从0开始，否则从1开始插入
            temp[isTail ? i : i + 1] = bs[i];
        }
        // 判断是否插入尾部，不是则插入头部
        temp[isTail ? bs.length : 0] = b;
        return temp;
    }

    /**
     * 合并两个字节数组
     * @param bs1 bs1
     * @param bs2 bs2
     * @return bs
     */
    public static byte[] mergeBytes(byte[] bs1,byte[] bs2) {
        byte[] temp = new byte[bs1.length + bs2.length];
        for(int i = 0;i < bs1.length; i++) {
            temp[i] = bs1[i];
        }
        for(int i = bs1.length; i < temp.length; i++) {
            temp[i] = bs2[i - bs1.length];
        }
        return temp;
    }
    /**
     * 整型转16进制字符串，如16 => 1即16进制的值 0x01
     * @param value int
     * @return 16进制字符串
     */
    public String int2HexString(int value) {
        return Integer.toHexString(value);
    }

    /**
     * 整型int转字节数组byte[]
     * @param val val，一个整数，而一个byte是8位二进制位，一个整数最大长度不超过4个byte即8*4=32位
     * @param isReserve 是否逆序
     * @param len 返回的数组长度
     * @return byte[]
     */
    public static byte[] int2Bytes(int val, boolean isReserve, int len) {
        int length;
        // 整型最大长度就是4个字节
        if (len < 0) {
            // 如果不是正数，则有多长就转化成多长，奇数的填0
            length = 4;
        } else {
            length = Math.min(len, 4);
        }
        byte[] temp = new byte[length];
        if (isReserve) {
            // 逆序
            for (int i = 0; i < length; i++) {
                temp[i] = (byte) (val & 0xff);
                val >>= 8;
            }
        } else {
            // 顺序
            for (int i = length - 1; i >= 0; i--) {
                temp[i] = (byte) (val & 0xff);
                val >>= 8;
            }
        }
        return temp;
    }

    /**
     * byte数组 转换成 16进制小写字符串
     * @param bytes byte数组
     * @param isReserve 是否逆序
     * @return 16进制小写字符串
     */
    public static String bytes2HexString(byte[] bytes, boolean isReserve) {
        if (bytes == null || bytes.length == 0) {
            return null;
        }
        if (isReserve) {
            for(int i = 0; i < bytes.length; i++) {
                bytes[bytes.length - i - 1] = bytes[i];
            }
        }
        StringBuilder hex = new StringBuilder();
        for (byte b : bytes) {
            hex.append(HEXES[(b >> 4) & 0x0F]);
            hex.append(HEXES[b & 0x0F]);
        }
        return hex.toString();
    }

    /**
     * 16进制字符串 转换为对应的 byte数组
     * @param hex 16进制字符串，为null则返回空数组
     * @param isReserve 是否逆序
     * @return byte数组
     */
    public static byte[] hexString2Bytes(String hex, boolean isReserve) {
        if (hex == null || hex.length() == 0) {
            return new byte[0];
        }
        char[] hexChars = hex.toCharArray();
        byte[] bytes = new byte[hexChars.length / 2];
        // 如果 hex 中的字符不是偶数个, 则忽略最后一个
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) Integer.parseInt("" + hexChars[i * 2] + hexChars[i * 2 + 1], 16);
        }
        if (isReserve) {
            bytes = new byte[bytes.length];
            for(int i = 0; i < bytes.length; i++) {
                bytes[bytes.length - i - 1] = bytes[i];
            }
        }
        return bytes;
    }
}
